#include <stdio.h>
#include <stdlib.h>

#define kMaxSize 10
typedef int NodePosition; /* 数组下标即结点位置 */
typedef struct BinaryTreeNode *BinaryTree;
struct BinaryTreeNode {
    NodePosition left; /* 左孩子指针 */
    NodePosition right; /* 右孩子指针 */
};

/* 链式队列定义 */
typedef enum {false, true} bool;
#define NIL -1
typedef NodePosition QElemSet;

typedef struct QueueNode *Position; /* 指针即结点位置 */
struct QueueNode {
    QElemSet data; /* 存储数据 */
    Position next; /* 链接队列中下一个元素的位置 */
};
typedef struct QueueHeadNode *Queue;
struct QueueHeadNode {
    int size; /* 链接队列中当前元素个数 */
    Position front; /* 链接队列的队首指针，初始化为NULL */
    Position rear; /* 链接队列的队尾指针，初始化为NULL */
};

void InitQueue(Queue queue) {
    /* 初始化一个空的链接队列 */
    queue->size = 0;
    queue->front = NULL;
    queue->rear = NULL;
}

bool IsEmpty(Queue queue) {
    /* 判断队列是否为空 */
    if (queue->size == 0)
        return true;
    else
        return false;
}

void EnQueue(Queue queue, QElemSet x) {
    Position new_node;

    new_node = (Position)malloc(sizeof(struct QueueNode));
    new_node->data = x;
    new_node->next = NULL;
    if (IsEmpty(queue)) { /* 特殊处理插入空队列的情况 */
        queue->rear = new_node;
        queue->front = new_node;
    } else {
        queue->rear->next = new_node;
        queue->rear = queue->rear->next;
    }
    queue->size++;
}

QElemSet GetFront(Queue queue) {
    if (IsEmpty(queue)) {
        printf("错误：队列为空。\n");
        return NIL;
    } else {
        return queue->front->data;
    }
}

void DeQueue(Queue queue) {
    Position temp;

    if (IsEmpty(queue)) {
        printf("错误：队列为空。\n");
    } else {
        temp = queue->front;
        queue->front = queue->front->next;
        free(temp);
        queue->size--;
        if (queue->front == NULL) {
            /* 特殊处理删除后变为空的队列 */
            queue->rear = NULL;
        }
    }
}

void DestroyQueue(Queue queue) {
    free(queue);
}
/* 队列定义结束*/

bool Visit(BinaryTree tree, NodePosition idx, bool first) {
    /* 访问下标为idx的树结点 */
    if (tree[idx].left == NIL && tree[idx].right == NIL) {
        /* 若tree[idx]是叶结点 */
        if (first == true) { /* 输出第1个叶结点*/
            printf("%d", idx);
            first = false;
        } else { /* 若不是第1个结点则多输出一个前置空格 */
            printf(" %d", idx);
        }
    }
    /* 不是叶结点则不要输出 */
    return first;
}

void LevelOrder(BinaryTree tree, NodePosition root) {
    /* 层序遍历以tree[root]为根的二叉树 */
    Queue queue;
    NodePosition node_ptr;
    bool first; /* 如果是第1次输出，则为true */

    queue = (Queue)malloc(sizeof(struct QueueHeadNode));
    InitQueue(queue); /* 初始化队列queue，用于存放结点 */
    first = true;
    EnQueue(queue, root); /* 树根结点入队 */
    while (IsEmpty(queue) == false) {
        node_ptr = GetFront(queue); /* 取出队首结点 */
        DeQueue(queue);
        if (node_ptr != NIL) { /* 结点非空 */
            first = Visit(tree, node_ptr, first); /* 访问结点 */
            EnQueue(queue, tree[node_ptr].left); /* 左子结点入队 */
            EnQueue(queue, tree[node_ptr].right);/* 右子结点入队 */
        }
    }
    DestroyQueue(queue);
}

NodePosition BuildTree(BinaryTree tree, int n) {
    /* 从输入中读取n个树结点的信息，并返回根结点下标 */
    int i;
    char left, right;
    bool *root;

    root = (bool *)malloc(sizeof(bool) * n);
    for (i = 0; i < n; i++) {
        root[i] = true; /* 每个结点都有可能是根结点 */
    }
    for (i = 0; i < n; i++) {
        scanf("%c %c\n", &left, &right);
        tree[i].left = (left == '-') ? NIL : (left - '0');
        if (tree[i].left != NIL) {
            root[tree[i].left] = false; /* 左孩子不可能是根 */
        }
        tree[i].right = (right == '-') ? NIL : (right - '0');
        if (tree[i].right != NIL) {
            root[tree[i].right] = false; /* 右孩子不可能是根 */
        }
    }
    for (i = 0; i < n; i++) {
        if (root[i] == true)
            break;
    }
    free(root);
    return i; /* i是根结点下标 */
}

int main(void) {
    int n;
    BinaryTree tree;
    NodePosition root;

    scanf("%d\n", &n);
    tree = (BinaryTree)malloc(sizeof(struct BinaryTreeNode) * n);
    root = BuildTree(tree, n);
    LevelOrder(tree, root);

    return 0;
}